import { Plugin } from './formulaCore.js';
export class SumPlugin extends Plugin {
    constructor() {
        super();
        this.name = 'SUM';
    }

    is2DArray(arr) {
        // 检查是否是数组
        if (!Array.isArray(arr)) {
            return false;
        }

        // 空数组也算二维数组
        if (arr.length === 0) {
            return true;
        }

        // 检查每一项是否也是数组
        return arr.every(item => Array.isArray(item));
    }

    execute(args) {
        console.log(args, 'args')
        if (this.is2DArray(args)) {
            return args.reduce((sum, value) => {
                let s = 0;
                value.forEach(item => {
                    // 获取对象的键值对
                    const key = Object.keys(item)[0]; // 例如 "B2"
                    const value = item[key];          // 例如 1 或 "公式参数字段2："

                    // 判断是否为数字
                    if (typeof value === 'number') {
                        sum += value; // 如果是数字，直接累加
                    } else if (!isNaN(parseFloat(value))) {
                        s += parseFloat(value); // 如果是字符串数字，转换为数字后累加
                    } else {
                        s += 0; // 如果不是数字，取 0
                    }
                });
                return sum + s
            }, 0);
        } else {
            let s = 0;
            args.forEach(item => {
                // 获取对象的键值对
                const key = Object.keys(item)[0]; // 例如 "B2"
                const value = item[key];          // 例如 1 或 "公式参数字段2："

                // 判断是否为数字
                if (typeof value === 'number') {
                    s += value; // 如果是数字，直接累加
                } else if (!isNaN(parseFloat(value))) {
                    s += parseFloat(value); // 如果是字符串数字，转换为数字后累加
                } else {
                    s += 0; // 如果不是数字，取 0
                }
            });
            return s
        }

    }
}

export class RoundPlugin extends Plugin {
    constructor() {
        super();
        this.name = 'ROUND';
    }

    /**
 * 模拟 Excel 的 ROUND 函数，根据指定小数位数进行四舍五入
 * @param {number} num - 需要四舍五入的原始数值
 * @param {number} decimals - 要保留的小数位数（支持负数，如-2表示四舍五入到百位）
 * @returns {number} - 四舍五入后的结果
 */
    excelRound(num, decimals) {
        // 计算精度调整因子：将目标小数位转换为整数位
        // 示例：decimals=2 → 10^2=100，将原数乘以100后，小数部分变为整数
        const factor = Math.pow(10, decimals);

        // 调整数值精度，将需要判断的小数位移到整数部分
        // 示例：num=1.234, decimals=2 → 1.234*100=123.4
        const adjustedNum = num * factor;

        // 分离调整后数值的整数部分（直接截断，不进行四舍五入）
        // 使用 Math.trunc 确保正负数处理一致（如 -2.5 → -2）
        const integerPart = Math.trunc(adjustedNum);

        // 计算调整后数值的小数部分
        // 示例：adjustedNum=123.4 → 123.4 - 123 = 0.4
        const decimalPart = adjustedNum - integerPart;

        let rounded;
        if (adjustedNum >= 0) {
            // 正数规则：小数部分 ≥ 0.5 时进位（如 2.5 → 3）
            rounded = decimalPart >= 0.5 ? integerPart + 1 : integerPart;
        } else {
            // 负数规则：小数部分 ≤ -0.5 时退位（如 -2.5 → -3）
            // 注意：由于 adjustedNum 是负数，decimalPart 也是负数或0
            rounded = decimalPart <= -0.5 ? integerPart - 1 : integerPart;
        }

        // 恢复原始精度并返回结果
        // 示例：rounded=3, decimals=0 → 3/1=3；rounded=1300, decimals=-2 → 1300/100=13 → 13*100=1300
        return rounded / factor;
    }

    execute(args) {
        console.log(args, 'args');
        const value0 = args[0];// 例如 1 或 B2
        let val0 = 0;
        if (typeof value0 === "object" && value0 !== null && JSON.stringify(value0)) {//如果是单元格，取单元格的值
            // 获取对象的键值对
            let key0 = Object.keys(value0)[0];
            val0 = value0[key0];
        } else {//如果不是单元格，直接取值
            val0 = value0;
        }
        const value1 = args[1];// 例如 1 或 B2
        let val1 = 0;
        if (typeof value1 === "object" && value1 !== null && JSON.stringify(value1)) {//如果是单元格，取单元格的值
            // 获取对象的键值对
            let key1 = Object.keys(value1)[0];// 例如 "B2"
            val1 = value1[key1];// 例如 1
        } else {//如果不是单元格，直接取值
            val1 = value1;
        }

        return this.excelRound(val0, val1);
    }
}

export class AbsPlugin extends Plugin {
    constructor() {
        super();
        this.name = 'ABS';
    }

    execute(args) {
        console.log(args, 'args');
        const value0 = args[0];// 例如 'qwe' 或 B2
        let val0 = 0;
        if (typeof value0 === "object" && value0 !== null && JSON.stringify(value0)) {//如果是单元格，取单元格的值
            // 获取对象的键值对
            let key0 = Object.keys(value0)[0];
            val0 = value0[key0];
        } else {//如果不是单元格，直接取值
            val0 = value0;
        }
        return Math.abs(val0);
    }
}

export class RightPlugin extends Plugin {
    constructor() {
        super();
        this.name = 'RIGHT';
    }

    execute(args) {
        console.log(args, 'args');
        const value0 = args[0];// 例如 'qwe' 或 B2
        let val0 = '';
        if (typeof value0 === "object" && value0 !== null && JSON.stringify(value0)) {//如果是单元格，取单元格的值
            // 获取对象的键值对
            let key0 = Object.keys(value0)[0];
            val0 = value0[key0];
        } else {//如果不是单元格，直接取值
            val0 = value0;
        }
        const value1 = args[1];// 例如 1 或 B2
        let val1 = 0;
        if (typeof value1 === "object" && value1 !== null && JSON.stringify(value1)) {//如果是单元格，取单元格的值
            // 获取对象的键值对
            let key1 = Object.keys(value1)[0];// 例如 "B2"
            val1 = value1[key1];// 例如 1
        } else {//如果不是单元格，直接取值
            val1 = value1;
        }
        let str = '';
        str = String(val0);//转字符串
        // 确保numChars是一个非负整数，并且不超过字符串的长度
        let numChars = Math.max(0, Math.min(val1, str.length));
        // 使用slice方法从字符串的右侧开始提取指定数量的字符
        return str.slice(-numChars);
    }
}

export class PowPlugin extends Plugin {
    constructor() {
        super();
        this.name = 'POW';
    }

    execute(args) {
        console.log(args, 'args');
        const value0 = args[0];// 例如 1 或 B2
        let val0 = 0;
        if (typeof value0 === "object" && value0 !== null && JSON.stringify(value0)) {//如果是单元格，取单元格的值
            // 获取对象的键值对
            let key0 = Object.keys(value0)[0];
            val0 = value0[key0];
        } else {//如果不是单元格，直接取值
            val0 = value0;
        }
        const value1 = args[1];// 例如 1 或 B2
        let val1 = 0;
        if (typeof value1 === "object" && value1 !== null && JSON.stringify(value1)) {//如果是单元格，取单元格的值
            // 获取对象的键值对
            let key1 = Object.keys(value1)[0];// 例如 "B2"
            val1 = value1[key1];// 例如 1
        } else {//如果不是单元格，直接取值
            val1 = value1;
        }
        return Math.pow(val0, val1);
    }
}